/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "物理.h"

using namespace std;


#include <ppl.h>


#include <S_键值序列容器.h>


#include "物体/实现包含物体.h"
#include <面/面.h>
#include <物体/物体.h>
#include <file_文件名数据.h>

#include "intern/后端/FLIP/FLIP对外接口.h"
#include "intern/后端/PBF/S_PhysicsPBD.h"
#include "intern/后端/PBF/PBF.h"

//#include "intern/后端/PhysX/C_物体管理/S_PhysicsPhysX.h"
//#include "intern/后端/PhysX/B_组合物体/S_Px刚体.h"
//#include "intern/后端/PhysX/B_组合物体/Px碰撞几何体.h"
//#include "intern/后端/PhysX/车辆.h"

//#include "intern/后端/PhysX/A_核心/Px物体形状创建.h"
//#include "intern/后端/PhysX/A_核心/Px物体形状创建.h"

//#include "intern/后端/FleX/C_实例管理/S_PhysicsFleX.h"
//#include "intern/后端/PhysX/C_物体管理/S_PhysicsPhysX.h"
//#include "intern/后端/ODE/C_物体管理/S_PhysicsODE.h"

//#include "intern/后端/Bullet/Bullet对外接口.h"
//#include "intern/后端/Mujoco/phy_Mujoco.h"

#include "intern/后端/MPM/MPM.h"





static S_键值序列容器<uint32, S_物理解算器*> g_物理解算器容器;

static C_StrKey分配器 g物理体名称分配器;



S_物理解算器* f_创建物理解算器(uint32 id) {
	g_物理解算器容器[id] = new S_物理解算器();
	return g_物理解算器容器[id];
}

S_Physics* f_phy_创建创建解算器(E_物理引擎 type, vec3 域大小, S_设备环境* ctx) {
	S_Physics* phy = 0;
	switch (type) {
		case E_物理引擎::E_物理引擎_Mujoco: {
			//phy = f_PhysMujoco_创建物理引擎();
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {
			phy = f_phy_创建MPM(*ctx);
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			//phy = f_创建Bullet物理引擎();
			break;
		case E_物理引擎::E_物理引擎_PBF:
			phy = f_pbf_创建PBF(*ctx);
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			phy = f_创建FLIP物理引擎(域大小);
			break;
	}

	phy->m_IdType = type;
	return phy;
}

//S_PhyVehicle* f_phy_创建车辆(S_PhyVehicleParams& 车身
//						 , S_PhyWheel** 车轮, uint32 车轮数量
//						 , S_PxAxleParams& 车轴属性) {
//	//return f_px_创建车辆(车身, 车轮, 车轮数量, 车轴属性);
//	return nullptr;
//}

//physx::PxActor* f_phy_get_车身刚体(S_PhyVehicle* v) {
//	//return f_px_get_车身刚体(v);
//	return nullptr;
//}

//S_PhyWheel* f_phy_创建车轮(float32 半径, float32 宽度, float32 重量, float32 动量, float32 阻尼
//					   , physx::vehicle2::PxVehicleSuspensionParams* 悬挂属性
//					   , physx::vehicle2::PxVehicleSuspensionForceParams* 悬挂物理属性
//					   , physx::vehicle2::PxVehicleTireForceParams* 轮胎属性
//) {
//	S_PhyWheel* w = new S_PhyWheel;
//	w->m_params = new physx::vehicle2::PxVehicleWheelParams;
//	w->m_params->radius = 半径;
//	w->m_params->halfWidth = 宽度;
//	w->m_params->mass = 重量;
//	w->m_params->moi = 动量;
//	w->m_params->dampingRate = 阻尼;
//
//	w->m_suspensionParams = new physx::vehicle2::PxVehicleSuspensionParams;
//	w->m_suspensionForceParams = new physx::vehicle2::PxVehicleSuspensionForceParams;
//	w->m_tireForceParams = new physx::vehicle2::PxVehicleTireForceParams;
//	(*w->m_tireForceParams) = (*轮胎属性);
//	(*w->m_suspensionParams) = (*悬挂属性);
//	(*w->m_suspensionForceParams) = (*悬挂物理属性);
//	
//	return w;
//}

void f_销毁物理解算器(uint32 id) {
	if (g_物理解算器容器.f_Key存在(id)) {
		g_物理解算器容器.f_remove(id);
	}
}

void f_phy_销毁物理解算器(S_Physics* phy) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco:
			//f_PhysMujoco_销毁物理引擎(phy);
			break;
		case E_物理引擎::E_物理引擎_MPM: {
			f_phy_销毁MPM(phy);
			break;
		}
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_销毁PBF(static_cast<S_PhysicspPBF*>(phy));
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			f_销毁FLIP物理引擎(phy);
			break;
	}
	
}

void f_phy_重构(S_Physics* phy, const std::string& path) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_MPM: {
			f_mpm_重置(*static_cast<S_PhysicsMPM*>(phy));
			break;
		}
		case E_物理引擎::E_物理引擎_Mujoco: {
			//f_PhysMujoco_重构(static_cast<S_PhysicsMujoco*>(phy), path);
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			//f_bullet_重置引擎((S_PhysicsBullet*)phy);
			break;
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_重构(*static_cast<S_PhysicspPBF*>(phy));
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}
}

void f_phy_重置运动(S_Physics* phy) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_MPM: {
			//f_mpm_重置(*static_cast<S_PhysicsMPM*>(phy));
			break;
		}
		case E_物理引擎::E_物理引擎_Mujoco: {
			//f_PhyMujoco_重置运动(static_cast<S_PhysicsMujoco*>(phy));
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_重置(*static_cast<S_PhysicspPBF*>(phy));
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}
}

void f_phy_构建缓存帧标记(S_Physics* phy, uint32 帧数量, const std::string& path) {
	if (f_file_文件是否存在(path)) {
		auto f = fopen(path.c_str(), "rb");
		if (f) {
			uint32 数量 = 0;
			fread(&数量, sizeof(uint32), 1, f);

			phy->m_缓存帧标记.resize(数量);
			fread(phy->m_缓存帧标记.data(), sizeof(uint8), 数量, f);

			fclose(f);
		}
	}
	else {
		phy->m_缓存帧标记.resize(帧数量);
		for (uint32 i = 0; i < 帧数量; ++i) {
			phy->m_缓存帧标记[i] = 0;
		}
	}

	
}

bool f_phy_清除模拟帧标记(S_Physics* phy, int32 s, int32 e, const std::string& path) {
	
	uint32 num = e;
	if (e <= 0) {
		num = phy->m_缓存帧标记.size();
	}

	for (uint32 i = s; i < num; ++i) {
		phy->m_缓存帧标记[i] = 0;
	}

	if (f_file_文件是否存在(path)) {
		auto f = fopen(path.c_str(), "wb");
		if (f) {
			fwrite(&num, sizeof(uint32), 1, f);
			fwrite(phy->m_缓存帧标记.data(), sizeof(uint8), num, f);
			fclose(f);
		}
	}

	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco: {
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			return f_pbf_内部重构(*static_cast<S_PhysicspPBF*>(phy));
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}

	return true;
}

void f_phy_标记帧缓存(S_Physics* phy, int32 帧, int32 标记, const std::string& path) {
	uint32 num = phy->m_缓存帧标记.size();
	if (num) {
		帧 = clamp(帧, 0, num - 1);

		phy->m_缓存帧标记[帧] = 标记;

		auto f = fopen(path.c_str(), "wb");
		if (f) {
			fwrite(&num, sizeof(uint32), 1, f);
			fwrite(phy->m_缓存帧标记.data(), sizeof(uint8), num, f);
			fclose(f);
		}
	}
}

void f_phy_步进解算(S_Physics* phy, float32 时间步进) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco: {
			//f_PhyMujoco_解算(static_cast<S_PhysicsMujoco*>(phy), 时间步进);
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {
			f_mpm_解算(static_cast<S_PhysicsMPM*>(phy), 时间步进);
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_解算(*static_cast<S_PhysicspPBF*>(phy), 时间步进);
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}
}

void f_phy_set飞溅粒子(S_Physics* phy, bool 是否开启, uint32 分配数量) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco: {
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_分配飞溅粒子(*static_cast<S_PhysicspPBF*>(phy), 是否开启, 分配数量);
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}
}

void f_phy_set模拟参数(S_Physics* phy, const S_PBF_Params& 模拟参数) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco: {
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {
			break;
		}
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_set模拟参数(*static_cast<S_PhysicspPBF*>(phy), 模拟参数);
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			break;
	}
}

uint32 f_phy_get解算器域分辨率(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_FLIP:

		break;
	}
	return uint32();
}

uint32 f_物理解算器名词是否存在(uint32 key){
	return g_物理解算器容器.f_GenName(key);
}

void f_Phy_构建静态网格碰撞划分(S_Physics* phy, float32 最小单元大小) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF:
		//f_PhysPBF_构建静态碰撞空间划分(phy, 最小单元大小);
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		//f_销毁FLIP物理引擎(phy);
		break;
	}
}




S_物理材质* f_创建材质(S_物理解算器* 解算器, float32 静摩擦, float32 动摩擦, float32 恢复系数, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			break;
	
		case E_物理引擎_PhysX:
			//return f_PhysX物理材质(解算器->m_PhysX, 静摩擦, 动摩擦, 恢复系数);
		
		//case E_物理引擎_NewTon:
		//	break;
		//case E_物理引擎_Chrono:
		//return new S_Chrono刚体(geom, mat);
		//	break;
		default:
			break;
	}

	return 0;
}














S_物理几何体* f_创建平面几何体(S_物理解算器* 解算器, const vec4& v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	
	case E_物理引擎_Bullet:
		//return f_Bullet平面几何体(v);
		break;

	case E_物理引擎_PhysX:
		//return f_PhysX平面几何体(解算器->m_PhysX, v);
		
	default:
		break;
	}
	
	return 0;
}

S_物理几何体* f_创建方体几何体(S_物理解算器* 解算器, const vec3& v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return f_Bullet长方体几何体(v);
			break;
	//case E_物理引擎_PhysX:
	//	return f_PhysX长方体几何体(解算器->m_PhysX, v);
	//case E_物理引擎_ODE:
	//	return f_ODE长方体几何体(解算器->m_ODE, v);
	//case E_物理引擎_NewTon:
	//	if(解算器->m_NewTon) return f_NewTon长方体几何体(解算器->m_NewTon, v);
	//	break;
	//case E_物理引擎_Chrono:
	//	return f_Chrono长方体几何体(v);
	//	break;
	
		default:
			break;
	}
	return 0;
}

S_物理几何体* f_创建球体几何体(S_物理解算器* 解算器, const float32 v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return f_Bullet球体几何体(v);
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}
	return 0;
}

S_物理几何体* f_创建凸壳物理包围几何(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return f_Bullet凸壳几何体(mesh);
		case E_物理引擎_PhysX:
			//return f_PhysX凸壳几何体(解算器->m_PhysX, mesh);
		default:
			break;
	}
	return 0;
}

S_物理几何体* f_创建网格物理几何体(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return f_Bullet网格几何体(mesh);
		case E_物理引擎_PhysX:
			//return f_PhysX凸壳几何体(解算器->m_PhysX, mesh);
			break;
	}
	return 0;
}

S_物理几何体* f_创建静态网格物理包围几何(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return new S_Bullet长方体几何体(v);
			break;
		case E_物理引擎_PhysX:
			//return f_PhysX网格几何体(解算器->m_PhysX, mesh);
			break;

	//case E_物理引擎_ODE:
	//	break;
	//case E_物理引擎_NewTon:
	//	break;
	
	}
	return 0;

}

void f_phy_创建物理几何体(E_物理引擎 物理引擎, S_物理几何体* 几何体) {
	

	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_Mujoco:
			break;
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎_Bullet:
	//return new S_Bullet长方体几何体(v);
			break;
	//case E_物理引擎_ODE:
	//	break;
	//case E_物理引擎_NewTon:
	//
	//	break;
	}
	return;
}

std::vector<S_物理体*> f_phy_get物理体(S_Physics* phy, E_物理几何体类型 几何类型) {
	switch (phy->m_IdType) {
		//case E_物理引擎::E_物理引擎_Mujoco:
		//	return f_PhyMujoco_get几何图形(static_cast<S_PhysicsMujoco*>(phy), 几何类型);
	
		case E_物理引擎::E_物理引擎_Bullet:
			//return new S_Bullet长方体几何体(v);
			break;
		case E_物理引擎_PhysX:
			break;

		//case E_物理引擎_FleX:
		//	break;
	}
	return {};
}

void f_Phy_内部网格填充绑定物体(S_Physics* phy, std::vector<S_物理体*>& Body) {
	switch (phy->m_IdType) {
		//case E_物理引擎::E_物理引擎_Mujoco:
		//	return f_PhyMujoco_构建内部几何体填充到物体(static_cast<S_PhysicsMujoco*>(phy), Body);

		case E_物理引擎::E_物理引擎_Bullet:
			//return new S_Bullet长方体几何体(v);
			break;
		case E_物理引擎_PhysX:
			break;
	}
}

uint32 f_phy_get肌腱数量(S_Physics* phy) {
	switch (phy->m_IdType) {
		//case E_物理引擎::E_物理引擎_Mujoco:
		//	return f_PhyMujoco_get肌腱数量(static_cast<S_PhysicsMujoco*>(phy));

		case E_物理引擎::E_物理引擎_Bullet:
			break;

		case E_物理引擎_PhysX:
			break;
	}
	return 0;
}

void f_phy_构建肌腱物体可视(S_Physics* phy, S_物体* Body) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco:
			//f_PhyMujoco_构建肌腱物体可视(static_cast<S_PhysicsMujoco*>(phy), Body);
			return;
		case E_物理引擎::E_物理引擎_Bullet:
			break;
	
		case E_物理引擎_PhysX:
			break;
	}
}

void f_phy_set肌腱力度(S_Physics* phy, float32* 力度, int32 id) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco:
			//f_PhyMujoco_set肌腱力度(static_cast<S_PhysicsMujoco*>(phy), 力度, id);
			return;
		case E_物理引擎::E_物理引擎_Bullet:
			break;
		
		case E_物理引擎_PhysX:
			break;
	}
}

void f_phy_施加力(S_Physics* phy, const S_施加物理力& f, E_施加力类型 type) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco:
			//f_PhyMujoco_施加力(static_cast<S_PhysicsMujoco*>(phy), f, type);
			return;
		case E_物理引擎::E_物理引擎_Bullet:
			break;

		case E_物理引擎_PhysX:
			break;
	}
}

void f_Phy_销毁内部物理几何体(S_物理几何体* geon) {

}















S_物理体* f_创建物理平面(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			//return new S_Bullet静态碰撞(geom, mat);
			break;
		
		case E_物理引擎_PhysX:
			//return f_PhysX静态(解算器->m_PhysX, geom, mat);
			break;

	//case E_物理引擎_Chrono:
	////return new S_Chrono刚体(geom, mat);
	//	break;
	//case E_物理引擎_FleX:
	//	break;
	}

	return 0;
		
}

S_物理体* f_创建静态碰撞(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t) {
	switch (geom.m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			//return f_Bullet静态(geom, mat);
		case E_物理引擎_PhysX:
			//return f_PhysX静态(解算器->m_PhysX, geom, mat);
			break;

	//case E_物理引擎_ODE:
	//	return f_ODE静态(解算器->m_ODE, geom, mat);
	//	break;
	//case E_物理引擎_NewTon:
	//	if (解算器->m_NewTon) return f_NewTon静态(解算器->m_NewTon, geom, mat);
	//	break;
	//case E_物理引擎_Chrono:
	//	return f_Chrono静态(geom, mat);
	//	break;
	//case E_物理引擎_FleX:
	//	//return f_FleX静态(geom, mat, t);
	//	break;
	
	}

	return 0;
}

S_物理体* f_创建刚体(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t, float32 重量) {
	//uint32 key = obj.m_ID;
	//if (S_物理体::f_get(key) == nullptr) {
	switch (geom.m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			//return f_Bullet刚体(geom, &mat);
		case E_物理引擎_PhysX:
			//return f_PhysX刚体(解算器->m_PhysX, geom, mat);
			break;

	//case E_物理引擎_ODE:
	//	return f_ODE刚体(解算器->m_ODE, geom, mat);
	//	break;
	//case E_物理引擎_NewTon:
	//	if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
	//	break;
	//
	//case E_物理引擎_Chrono:
	//	return f_Chrono刚体(geom, mat);
	//	break;
	//case E_物理引擎_FleX:
	//	//return f_FleX刚体(geom, mat, t, 重量);
	//	break;
	//default:
	//	break;
	}
	
	return 0;
}



S_物理体* f_创建控制物理体(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t) {
	switch (geom.m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			//return f_Bullet控制(geom, mat);
		case E_物理引擎_PhysX:
			//return f_PhysX控制Body(解算器->m_PhysX, geom, mat);
			break;

	//case E_物理引擎_ODE:
	//	//return f_ODE刚体(解算器->m_ODE, geom, mat);
	//	break;
	//case E_物理引擎_NewTon:
	//	//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
	//	break;
	//
	//case E_物理引擎_Chrono:
	//	//return f_Chrono刚体(geom, mat);
	//	break;
	//case E_物理引擎_FleX:
	//	//return f_FleX刚体(geom, mat, t, 重量);
	//	break;
	//
	//	break;
	//default:
	//	break;
	}
	return 0;
}

S_物理体* f_创建物理边界(S_物理解算器* 解算器, vec3 size, const S_Tranform& t, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			return 0;
		//case E_物理引擎_ODE:
		//	//return f_ODE刚体(解算器->m_ODE, geom, mat);
		//	break;
		//case E_物理引擎_NewTon:
		//	//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		//	break;
		//case E_物理引擎_Chrono:
		//	//return f_Chrono刚体(geom, mat);
		//	break;
		//case E_物理引擎_FleX:
		//	//return f_FleX刚体(geom, mat, t, 重量);
		//	break;
		//
		//default:
		//	break;
	}
	return nullptr;
}

S_物理体* f_Phy_create刚体(S_Physics* phy, S_物理材质* 材质) {
	switch (phy->m_IdType) {
	
		case E_物理引擎::E_物理引擎_PBF: {
			//return f_PhysPBF_创建刚体(材质);
		} 

		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		} 

	}
	return nullptr;
}

S_物理体* f_Phy_create刚体(S_Physics* phy, S_物理几何体& geom, S_物理材质* 材质) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Bullet: {
			//return f_Bullet刚体(geom, 材质);
		}

		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		} 
	}
	return nullptr;
}

S_物理体* f_phy_create物理体(S_物理几何体* geom, S_物理材质* 材质, E_物理引擎 phy_type) {
	S_物理体* body = new S_物理体(0);
	
	//body->m_Name = g物理体名称分配器.f_Gen(body->m_Name);

	return body;
}

void f_phy_销毁物理体(S_物理体* body) {
	
	//g物理体名称分配器.f_Move(body->m_Name);

	delete body;
}

S_物理体* f_Phy_create粒子发射(S_Physics* phy, uint32 粒子数, S_物理材质* 材质) {
	S_物理体* body = nullptr;
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			//body = f_PhysPBF_创建粒子发射(粒子数, 材质);
			break;
		} 
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		} 
	}

	if(body) body->m_物理引擎枚举 = phy->m_IdType;
	return body;
}

S_物理体* f_创建物理车轮(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_车轮参数& 属性) {
	switch (geom.m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			//return f_Bullet刚体(geom, &mat);
		case E_物理引擎_PhysX:
			//return f_PhysX创建车轮(解算器->m_PhysX, 属性, geom, mat);
			break;
	}

	return 0;
}

S_物理体* f_创建物理车辆(S_物理解算器* 解算器, S_车体参数& 车体参数) {
	S_物理体* body = 0;
	
	switch (车体参数.m_车体刚体->m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			//return f_Bullet创建车(解算器->m_Bullet, 车体参数);
		case E_物理引擎_PhysX:
			//return f_PhysX创建车(解算器->m_PhysX, 车体参数);
			break;
	}

	return body;
}

void f_Phy_创建流体(S_Physics* phy, S_物理体* body) {

}

void f_Phy_销毁物理体(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎::E_物理引擎_Bullet: {
			delete body;
			break;
		}
		case E_物理引擎::E_物理引擎_PBF: {
			delete body->m_几何体; 
			break;
			//return f_PhyPBF_销毁物理体(body);
		}

		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
}


void f_车辆物理体绑定物体(S_物理解算器* 解算器, S_物理体* 车, vector<void*>& 车体) {
	//return;
	/*auto* 车辆 = dynamic_cast<S_Px车*>(车);
	if (车辆) {
		auto& Core = dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Core;
		bool 成功 = 车辆->f_test(&Core, dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Px场景s[0], 车辆->m_车体参数, 车辆->m_车轮参数);
		if (!成功) return;

		auto& vehicle = *车辆->mVehicleManager.getVehicle(0);

		PxShape* carShapes[PX_MAX_NB_WHEELS + 1];
		const PxU32 nbShapes = vehicle.getRigidDynamicActor()->getNbShapes();
		const PxRigidDynamic& vehicleActor = *vehicle.getRigidDynamicActor();
		vehicleActor.getShapes(carShapes, nbShapes);

		for (uint32 i = 0; i < nbShapes; ++i) {
			carShapes[i]->userData = 车体[i];
		}


		const physx::PxU32 nbShapes = 车辆->m_车体刚体->getNbShapes();
		physx::PxShape* 子物体[64];
		车辆->m_车体刚体->getShapes(子物体, nbShapes);
		for (uint32 i = 0; i < nbShapes; ++i) {
			子物体[i]->userData = 车体[i];
		}
		//车辆->m_车体刚体->userData = 车体[4];
		//车辆->m_车体形状[0]->userData = 车体[4];
	}*/
}

/*void f_车辆物理体绑定物体(S_物理体* 车, vector<void*>& 车体, vector<void*>& 车轮) {
	auto* 车辆 = dynamic_cast<S_Px车*>(车);
	if (车辆) {
		const physx::PxU32 nbShapes = 车辆->m_车体刚体->getNbShapes();
		physx::PxShape* 子物体[64];
		车辆->m_车体刚体->getShapes(子物体, nbShapes);
		for (uint32 i = 0; i < 车辆->m_车体形状.size(); ++i) {
			车辆->m_车体形状[i]->userData = 车体[i];
			//车辆->m_车体刚体->userData = 车体[i];
		}
		for (uint32 i = 0; i < 车辆->m_车轮形状.size(); ++i) {
			车辆->m_车轮形状[i]->userData = 车轮[i];
		}
	}
}*/



/*void f_创建车(S_物理解算器* 解算器, 
				S_物体* 车体, 
				const S_车体参数& 车体参数, 
				vector<S_物体*> 车轮, 
				const vector<S_车轮参数>& 车轮参数, 
				const S_三角Mesh& 车体mesh
				//const vector<S_三角Mesh>& 车轮meshs
) {
	S_PhysX* px = dynamic_cast<S_PhysX*>(解算器->m_PhysX);
	//px->f_add车辆(车体, 车体参数, 车轮, 车轮参数);

	auto& PxCore = px->m_Core;


	uint32 车轮数 = 车轮参数.size();

	S_Px车* px车 = new S_Px车(PxCore.m_Physics, PxCore.m_Cooking, 车体参数, 车轮数);

	px车->m_车体刚体->userData = 车体;

	px车->f_add构建车体(PxCore.m_Physics, PxCore.m_Cooking, 车体mesh);

	for (uint32 i = 0; i < 车轮数; ++i) {
		S_Px车轮* px车轮 = new S_Px车轮(PxCore.m_Physics, PxCore.m_Cooking, 车轮参数[i]);
		//vec3 轮胎局部位置 = c车体->f_get位置();
		px车->f_add构建车轮(px车轮);
		px车轮->m_车轮形状->userData = 车轮[i];
	}

	//m_Px场景s[0]->addActor(*px车->m_车体刚体);

}*/


void f_Phy_set肌腱力度(S_Physics* phy, float32* value, int32 num) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:

		break;
	}
}

void f_Phy_应用力(S_Physics* phy, const S_施加物理力& 互交) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Mujoco:
			//f_PhyMujoco_施加力(static_cast<S_PhysicsMujoco*>(phy), 互交);
			break;
	}
}

S_物理体* f_create流体粒子(S_物理解算器* 解算器, S_物理材质& mat, const S_Tranform& t, uint32 num, E_物理引擎 物理引擎) {
	S_物理体* body = 0;

	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			//body = f_PhysPBF_创建物理流体(解算器->m_PBF, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
	}
	return body;
}

S_物理体* f_Phy_create流体(S_Physics* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t, E_物理引擎 物理引擎) {
	S_物理体* body = 0;

	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_FLIP:
			body = f_FLIP创建流体(解算器, geom, mat, t);
			break;
		case E_物理引擎::E_物理引擎_PBF:
			break;
		case E_物理引擎_PhysX:
			break;
	}
	return body;
}

bool f_Phy_切换物理体类型(E_物理引擎 IdType, S_物理体* body, E_物理体类型 类型) {
	body->m_物理引擎枚举 = IdType;

	if (类型 == body->m_物理体类型) {
		return false;
	}

	switch (IdType) {
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎::E_物理引擎_FLIP:
			f_FLIP_切换物理体类型(body, 类型);
			break;
		case E_物理引擎::E_物理引擎_PBF:
			//f_PhysPBF_切换物理体类型(body, 类型);
			break;
	}
	
	return false;
}

void f_Phy_重置发射源(S_物理体* body)
{
	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF:
	case E_物理引擎_PhysX:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	}
}

S_体素* f_Phy_get发射源体素(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎::E_物理引擎_PBF:
		case E_物理引擎::E_物理引擎_FLIP:
			return f_FLIP_get物体体素(body);
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎_Bullet:
			break;
	}

	return nullptr;
}

S_域区* f_Phy_get域属性(S_Physics* phy) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_FLIP:
			return f_FLIP_get域属性(phy);
		case E_物理引擎::E_物理引擎_PBF:
			return phy->f_get域属性();
		case E_物理引擎_PhysX:
			break;
	}
	return nullptr;
}

uint64 f_Phy_get粒子数量(S_Physics* phy) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_FLIP:
			break;
		case E_物理引擎::E_物理引擎_PBF:
			//return f_PBF_get粒子总数(phy);
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎_Bullet:
			break;
	}

	return uint64();
}

float32 f_Phy_get粒子大小(S_Physics* phy) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF:
			//return f_PBF_get粒子大小(phy);
		case E_物理引擎_PhysX:
			break;
		case E_物理引擎_Bullet:
			break;
	}

	return 1.0f;
}







void f_Phy_get域中粒子(S_Physics* phy, const vec3& coord, std::vector<vec3>& particle) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF:
			//f_PBF_get域中粒子(phy, coord, particle);
			break;
		case E_物理引擎::E_物理引擎_PhysX:

			break;
		case E_物理引擎::E_物理引擎_Bullet:

			break;
	}
}

uvec2 f_Phy_get粒子区间(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PBF_get物理体粒子区间(body);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
	}
	return uvec2();
}

uvec4 f_Phy_get粒子发射区间(S_物理体* body, float32 速率) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PBF_get粒子发射区间(body, 速率);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
	}
	return uvec4();
}

uint64 f_Phy_get发射总数(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PBF_get发射总数(body);

		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
	return uint64();
}

void f_phy_发射粒子(S_Physics* phy, S_物理体* body, const S_Vec3Array* point, const S_Vec3Array* vel) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF:
			f_pbf_发射粒子(*dynamic_cast<S_PhysicspPBF*>(phy), body, point, vel);
			break;
		case E_物理引擎::E_物理引擎_PhysX:

			break;
		case E_物理引擎::E_物理引擎_Bullet:

			break;
	}
}

void f_phy_initPBF模拟参数(S_PBF_Params& params) {
	f_pbf_初始化解算参数(params);
}

S_物理体* f_phy_get物理体(S_Physics* phy, std::u16string& bodyName) {
	S_物理体* body = nullptr;
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			auto it = dynamic_cast<S_PhysicspPBF*>(phy)->m_物理体.find(bodyName);
			if(it != dynamic_cast<S_PhysicspPBF*>(phy)->m_物理体.end()) body = (*it).second;
			break;
		}
		case E_物理引擎::E_物理引擎_PhysX:

			break;
		case E_物理引擎::E_物理引擎_Bullet:

			break;
	}
	return body;
}







void f_phy_添加物理体(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎_Bullet:
			解算器->m_Bullet->f_添加物理体(body, sceneKey);
			break;

		case E_物理引擎_PhysX:
			解算器->m_PhysX->f_添加物理体(body, sceneKey);
			break;
	}
}

void f_物理体从引擎移除(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (body->m_物理引擎枚举) {
		case E_物理引擎_Bullet: {
			解算器->m_Bullet->f_移除物理体(body, sceneKey);
			break;
		}
		case E_物理引擎_PhysX:
			解算器->m_PhysX->f_移除物理体(body, sceneKey);
			break;
	}
	
}

bool f_Phy_物理体添加到引擎(S_Physics* phy, S_物理体* body) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			return f_PBF_添加物体(phy, body);
		} break;

		case E_物理引擎::E_物理引擎_PhysX: {

		} break;
	}

	return false;
}

void f_phy_添加物理体(S_Physics* phy, S_PhyBodyArray* body) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Bullet: {
			//f_bullet_构建物理体((S_PhysicsBullet*)phy, body);
			break;
		}
		case E_物理引擎::E_物理引擎_Mujoco: {
			//f_PhyMujoco_构建物理体((S_PhysicsMujoco*)phy, body);
			break;
		}
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_添加物理体(*dynamic_cast<S_PhysicspPBF*>(phy), body);
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {
			f_mpm_添加物理体(phy, body);
			break;
		}
		case E_物理引擎::E_物理引擎_PhysX: {
			break;
		} 
	}
}

void f_Phy_add静态碰撞网格(S_Physics* phy, std::vector<vec3>& vert, std::vector<uvec3>& index) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		return f_PhysPBF_add静态碰撞网格(phy, vert, index);
	} break;

	case E_物理引擎::E_物理引擎_PhysX: {

	} break;
	}
}


void f_物理体添加碰撞回调(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		解算器->m_Bullet->f_添加物理体(body, sceneKey);
		return;

	case E_物理引擎_PhysX:
		解算器->m_PhysX->f_添加物理体(body, sceneKey);
		break;
	}
}

车辆容器_t f_get车辆(S_物理解算器* 解算器, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		//return f_getBullet车辆(解算器->m_Bullet);
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return 车辆容器_t();
}

void f_施加力(S_物理解算器* 解算器, S_物理体* body, const vec3& 力, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_施加单方向外力(解算器->m_PBF, body, 力);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	};
}

void f_Phy_设置粒子数量(S_物理解算器* 解算器, S_物理体* body, uint32 num, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			f_PhysPBF_设置流体粒子数量(解算器->m_PBF, body, num);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}
}

void f_Phy_拷贝粒子坐标(S_物理解算器* 解算器, S_物理体* body, vec3* c, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			f_PhysPBF_取粒子坐标(解算器->m_PBF, body, c);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
	}
}

void f_Phy_拷贝粒子速度(S_物理解算器* 解算器, S_物理体* body, vec3* c, E_物理引擎 物理引擎) {
}








vec3* f_Phy_映射粒子坐标(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	vec3* p = 0;
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子坐标(解算器->m_PBF, body);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	return nullptr;
}

vec3* f_Phy_映射粒子速度(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子速度(解算器->m_PBF, body);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	return nullptr;
}

vec3* f_Phy_映射粒子外力(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子外力(解算器->m_PBF, body);
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}
	return nullptr;
}







void f_Phy_set解算器域分辨率(S_Physics* phy, E_物理引擎 type, uint32 分辨率, vec3 世界大小, float32 单元间隔) {
	switch (type) {
	case E_物理引擎::E_物理引擎_FLIP: {
		S_域区* vo = f_FLIP_get域属性(phy);

		vo->m_单元属性.m_分辨率 = { 分辨率 ,分辨率 ,分辨率 };

		if(vo->m_Mask) free(vo->m_Mask);
		vo->m_Mask = (uint8*)calloc(vo->m_单元属性.m_分辨率.x * vo->m_单元属性.m_分辨率.y * vo->m_单元属性.m_分辨率.z, sizeof(uint8));

		f_FLIP_set解算器域分辨率(phy, 0);

		break;
	}
		
	}
}

void f_Phy_set解算器域分辨率(S_Physics* phy, float32 分辨率) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PBF_set粒子半径(phy, 分辨率);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {
		
	} break;

	}
}

void f_phy_set解算器域(S_Physics* phy, const vec3& 域大小, const vec3& 域偏移, float32 单元大小) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_设置网格维度(*dynamic_cast<S_PhysicspPBF*>(phy), 域大小, 域偏移, 单元大小);
			break;
		}

		case E_物理引擎::E_物理引擎_MPM: {
			f_mpm_设置MPM网格维度(phy, 域大小, 域偏移, 单元大小);
			break;
		}
	}
}


void f_Phy_set流体速度(S_Physics* 解算器, S_Object* body) {
	S_域区* vo = f_FLIP_get域属性(解算器);

	S_物体* obj = dynamic_cast<S_物体*>(body);

	//f_fromMesh创建体素(vo, f_ob_from物体Mesh(obj), { 0,0,0 }, { 0,0,0,1 }, { 1,1,1 }, 0.1);

}


void f_Phy_set粒子发射(S_物理体* e, std::vector<S_VN>& vn) {
	switch (e->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF: {
		S_体素* volex = f_Phy_get发射源体素(e);

		uint32 num = vn.size();
		volex->m_坐标.resize(num);
		volex->m_法线.resize(num);
		for (uint32 i = 0; i < num; ++i) {
			volex->m_坐标[i] = vn[i].vert;
			volex->m_法线[i].x = vn[i].normal.x;
			volex->m_法线[i].y = vn[i].normal.y;
			volex->m_法线[i].z = vn[i].normal.z;
		}


		//f_PhysPBF_set粒子发射数量(e, vn.size());
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set粒子发射最大数量(S_物理体* e, uint64 num) {
	switch (e->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_set粒子发射数量(e, num);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set流体飞溅粒子数量(S_Physics* 解算器, uint32 num)
{
	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_set飞溅粒子数量(解算器, num);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set粒子区间(S_物理体* body, const uvec2& 区间, uint64 全局偏移)
{
	body->m_全局偏移 = 全局偏移;

	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_set流体粒子区间(body, 区间);
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
}

void f_Phy_添加物理体(S_Physics* 解算器, std::vector<S_物理体*>& body) {

	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_Bullet: {
		//f_Bullet_添加物理体(解算器, body);
		break;
	}

	case E_物理引擎::E_物理引擎_Mujoco: {
		//f_PhyMujoco_添加物理体(static_cast<S_PhysicsMujoco*>(解算器), body);
		break;
	}
		case E_物理引擎::E_物理引擎_PBF: {
			for (auto ob : body) {
				if (ob->m_几何体) {
					S_物体* obj = dynamic_cast<S_物体*>(ob->m_绑定物体);
					f_PBF_添加物体(解算器, ob);

				}
				//S_体素* v = f_Phy_get发射源体素(ob);
				//f_fromMesh创建体素(*vo, f_ob_from物体Mesh(obj), { 0,0,0 }, { 1,0,0,0 }, { 1,1,1 }, 0.1);
				//uint32 发射源层 = v->m_维度.x * v->m_维度.y;
				//uint32 层 = vo->m_分辨率.x * vo->m_分辨率.y;
				/*Concurrency::parallel_for<uint32>(0, v->m_维度.z, [&](uint32 z) {
					for (uint32 y = 0; y < v->m_维度.y; ++y) {
						for (uint32 x = 0; x < v->m_维度.x; ++x) {

						}
					}
				});*/
			}
			//f_FLIP发射流体(解算器, body);
			break;
		}

		case E_物理引擎::E_物理引擎_FLIP: {
			S_域区* vo = f_FLIP_get域属性(解算器);
		

			for (auto ob : body) {
				S_物体* obj = dynamic_cast<S_物体*>(ob->m_绑定物体);

				S_体素* v = f_Phy_get发射源体素(ob);

				uint32 发射源层 = v->m_维度.x * v->m_维度.y;
				uint32 层 = vo->m_单元属性.m_分辨率.x * vo->m_单元属性.m_分辨率.y;



				Concurrency::parallel_for<uint32>(0, v->m_维度.z, [&](uint32 z) {
					for (uint32 y = 0; y < v->m_维度.y; ++y) {
						for (uint32 x = 0; x < v->m_维度.x; ++x) {
							vec3 offset = (obj->m_变换.position - vo->m_单元属性.m_域世界偏移) / vo->m_单元属性.m_单元大小;
							ivec3 gOffset = { offset.x, offset.y, offset.z };
							gOffset.x += x;
							gOffset.y += y;
							gOffset.z += z;
							//uvec3 gOffset = vec_Max({ offset.x, offset.y, offset.z }, uvec3{0,0,0});

							if (gOffset.x < 0 || gOffset.x >= vo->m_单元属性.m_分辨率.x) break;
							if (gOffset.y < 0 || gOffset.y >= vo->m_单元属性.m_分辨率.y) break;
							if (gOffset.z < 0 || gOffset.z >= vo->m_单元属性.m_分辨率.z) break;

							uint64 发射源ID = 发射源层 * z + v->m_维度.x * y + x;
							uint64 ID = 层 * gOffset.z + vo->m_单元属性.m_分辨率.x * gOffset.y + gOffset.x;

							if (v->m_Mask[发射源ID]) {
								vo->m_Mask[ID] = 1;
							}

						}
					}
					});

			}

			f_FLIP发射流体(解算器, body);

			break;
		}
		
	}

}

void f_phy_添加力(S_Physics* phy, const std::vector<S_PBF_force>& 力) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_添加力(*dynamic_cast<S_PhysicspPBF*>(phy), 力);
			break;
		}
		case E_物理引擎::E_物理引擎_MPM: {

			break;
		}
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
}

void f_phy_更新粒子绘制缓存(S_Physics* phy, float32 子帧步进) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_MPM: {
			
			break;
		}
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_更新粒子渲染(*dynamic_cast<S_PhysicspPBF*>(phy), 子帧步进);
			break;
		}
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
}

void f_Phy_取流体调试数据(S_Physics* 解算器, void* data) {
	switch (解算器->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			f_PBF_流体数据写入到顶点缓存(解算器, (vec4*)data);
		} break;

		case E_物理引擎::E_物理引擎_FLIP: {
			f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
		} break;
	}
}

void f_Phy_取流体调试数据(S_Physics* 解算器, S_物体* ob, uint32 信息类型) {
	switch (解算器->m_IdType) {
		case E_物理引擎::E_物理引擎_MPM: {
			f_mpm_取调试粒子(解算器, ob);
			break;
		}
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_取调试粒子(*dynamic_cast<S_PhysicspPBF*>(解算器), ob, 信息类型);
			break;
		}
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
}

void f_Phy_取体素调试数据(S_Physics* 解算器, std::vector<vec4>& data) {
	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PBF_体素数据写入到顶点缓存(解算器, data);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {
		//f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
	} break;
	}
}


void f_Phy_get静态碰撞空间树调试数据(const S_Physics* 解算器, std::vector<vec4>& data, bool 不包含空单元) {
	switch (解算器->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			if (不包含空单元) {
				f_PBF_静态碰撞单元树写入缓存(解算器, data);
			}
			else {
				f_PBF_静态碰撞空间树写入缓存(解算器, data);
			}
		} break;

		case E_物理引擎::E_物理引擎_FLIP: {
			//f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
		} break;
	}
}

bool f_phy_读取缓存(S_Physics* phy, const std::string path[2], E_物理缓存方式 缓存方式, int32 帧) {
	
	//if(帧 >= phy->m_缓存帧标记.size() || phy->m_缓存帧标记[帧] <= 0) return false;
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			int32 上一帧 = 帧 - 1;
			if (上一帧 < phy->m_缓存帧标记.size() && phy->m_缓存帧标记[上一帧] > 0) {
				f_pbf_读取缓存(*dynamic_cast<S_PhysicspPBF*>(phy), path[1], 缓存方式, true);
			}
			if (帧 < phy->m_缓存帧标记.size() && phy->m_缓存帧标记[帧] > 0) {
				return f_pbf_读取缓存(*dynamic_cast<S_PhysicspPBF*>(phy), path[0], 缓存方式, false);
			}
		}
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		} 
	}
	return false;
}

void f_phy_写入缓存(S_Physics* phy, const std::string& path, E_物理缓存方式 缓存方式) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			f_pbf_写入缓存(*dynamic_cast<S_PhysicspPBF*>(phy), path, 缓存方式);
			break;
		}
		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		}
	}
}

void f_phy_模拟(S_Physics* phy, int32 帧) {
	
}




/*void f_取碰撞物体(S_物理解算器* 解算器, std::vector<S_物理体>& objs, uint32 scenekey, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		解算器->m_Bullet->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_Chrono:
		解算器->m_Chrono->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
	{
		S_PhysX* px = dynamic_cast<S_PhysX*>(解算器->m_PhysX);
		px->f_添加物理体(body, sceneKey);
	}
	break;
	default:
		break;
	}
}*/


//S_物理体* f_phy_create物理体(E_物理引擎 type) {
//	S_物理体* body = nullptr;
//	switch (type) {
//		case E_物理引擎::E_物理引擎_Mujoco: {
//			body = new S_物理体(0);
//			break;
//		}
//		case E_物理引擎::E_物理引擎_Bullet: {
//			
//			break;
//		}
//		case E_物理引擎::E_物理引擎_PBF: {
//			
//			break;
//		}
//		case E_物理引擎::E_物理引擎_FLIP: {
//			break;
//		}
//	}
//	return body;
//}



/*S_PBF粒子发射* f_Phy_create粒子发射(S_Physics* phy, S_物理体* body) {
	S_PBF粒子发射* e = (S_PBF粒子发射*)malloc(sizeof(S_PBF粒子发射));
	e->m_Body = body;
	e->m_偏移 = 0;
	e->m_数量 = 0;
	e->m_位置坐标 = nullptr;
	e->m_发射方向 = nullptr;

	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_创建粒子发射(
	} break;
	case E_物理引擎::E_物理引擎_FLIP: {
	} break;
	}
	return e;
}*/
